在 Python 中，tuple（元組）是一種 有序的、不可變 的集合。
與 list（列表）類似，它可以存儲多個不同類型的元素，
但不同點在於 tuple 一旦創建後，裡面的元素就不能被修改、添加或刪除。

特點

• 有序性：tuple 中的元素是有序排列的，可以通過索引來訪問，如 tuple[0]。
• 不可變性：tuple 一旦創建，元素無法更改（無法增加、刪除或改變元素值）。
• 使用小括號：tuple 使用小括號 () 來創建，元素之間用逗號隔開。

創建元組的方式

my_tuple = (1, 2, 3, 'a', 'b')

# 單個元素的元組（需要一個逗號）
single_element_tuple = (5,)

為什麼單個元素的元組（需要一個逗號）？
為了讓 Python 確認你要創建的是一個單元素的元組，而不是普通的括號包裹數值，需要在單個元素後加逗號。

範例解釋

#沒有逗號的情況
single_element_tuple = (5)
print(type(single_element_tuple))  # 輸出 <class 'int'>
#加上逗號的情況
single_element_tuple = (5,)
print(type(single_element_tuple))  # 輸出 <class 'tuple'>

語法糖 自動被打包成一個 元組（tuple）

在 Python 中，當使用逗號分隔多個值時，這些值會自動被打包成一個元組（tuple），
即使你不明確使用圓括號。

packed_tuple = 1, 2, 3  # 沒有括號
print(packed_tuple)  # (1, 2, 3)
print(type(packed_tuple))# <class 'tuple'>

訪問元組中的元素

my_tuple = (1, 2, 3, 'a', 'b')
print(my_tuple[0])  # 輸出 1
print(my_tuple[3])  # 輸出 'a'

不可變性

my_tuple = (1, 2, 3)
# my_tuple[0] = 10  # 這行會報錯，因為元組不可修改

元組（Tuple）的常用操作

元組解包（Unpacking）

想像元組是裝東西的「盒子」，裡面放了不同的三個數字。比如：1、2 和 3。

my_tuple = (1, 2, 3)

解包（Unpacking） 就像是你把這些東西從盒子裡拿出來，分給不同的人（變數）。比如：

a, b, c = my_tuple

這裡，a 得到了 1，b 得到了 2，c 得到了 3。就像是你把盒子裡的東西一個一個分配給不同的變數。

所以元組解包（Unpacking） 有點像是javascript的解構概念？

是的，元組解包（Unpacking） 在 Python 中的概念，確實與 JavaScript 的解構賦值（Destructuring Assignment） 非常相似。
兩者都涉及將數組或對象（在 JavaScript 中）或元組（在 Python 中）的值拆解出來，並賦值給不同的變數。

比較範例

Python 中的元組解包（Unpacking）

my_tuple = (1, 2, 3)
a, b, c = my_tuple
print(a, b, c)  # 1 2 3

JavaScript 中的解構賦值（Destructuring Assignment）

const myArray = [1, 2, 3];
const [a, b, c] = myArray;
console.log(a, b, c);  // 1 2 3

主要類似之處：

多個值的分配：兩者都從多個值的容器（元組或數組）中，將每個元素提取出來，並分配給不同的變數。
簡化代碼：這些語法讓我們不用手動逐個提取元素，簡化了代碼的書寫。

問題：如何交換兩個變數的值？

Python 的簡單方法
Python 使用了元組這個概念，類似於打包禮物的包裹。

• 首先，它把 b 和 a 這兩個東西（香蕉和蘋果）包在一起變成一個包裹packing。
• 然後它打開這個包裹unpacking，分別把裡面的香蕉給 a，蘋果給 b。

a = apple
b = banana

# 這一步發生了 tuple packing 和 unpacking
a, b = banana, apple #右邊的值（香蕉和蘋果）包在一起變成一個包裹。(banana, apple )

# 現在 a 和 b 的值已經交換
print(a)  # 10
print(b)  # 5

使用*解包：更靈活的資料處理

在 Python 中，*號在解包（unpacking）時扮演著非常重要的角色，它讓我們可以更靈活地處理可迭代對象（如列表、元組等）。

基本用法

將可迭代對象的元素分配給多個變數：
當我們知道可迭代對象的元素個數時，可以直接將元素一一分配給變數。但當元素個數不確定或想將多餘的元素收集到一個變數中時，* 就派上用場了

numbers = [1, 2, 3, 4, 5]
a, b, *c = numbers
print(a)  # 输出 1
print(b)  # 输出 2
print(c)  # 输出 [3, 4, 5]

在這個例子中，*c 表示將剩餘的元素收集到列表 c 中。

將字典解包：

* 也可以用於解包字典。

person = {'name': 'Alice', 'age': 30, 'city': 'New York'}
name, *rest = person.items()
print(name)  # 输出 ('name', 'Alice')
print(rest)  # 输出 [('age', 30), ('city', 'New York')]

進階用法

• 函數參數：
  • * 可以用來表示可變長度的位置參數。

def greet(*names):
    for name in names:
        print(f"Hello, {name}!")

greet('Alice', 'Bob', 'Charlie')

• 函數返回值：
  • * 可以用來將可迭代對象的元素拆開作為函數的返回值。

def split_list(numbers):
    return numbers[:2], *numbers[2:]

a, *b = split_list([1, 2, 3, 4])
print(a)  # 输出 [1, 2]
print(b)  # 输出 [3, 4]

注意事項:*只能出現在賦值語句的左側或函數定義的參數列表中。

什麼是 Mutable objects in tuples？

在 Python 中，元組（tuple）是不可變的immutable，
這意味著一旦創建了元組，裡面的元素就不能被修改或重新賦值。
然而，元組可以包含可變的對象，這些可變對象可以在元組內被修改，
儘管元組本身仍然是不可變的。這就是可變對象在元組中的情況。

例子解釋：

• 元組本身不可變：
  元組中的每個元素的值和位置不能被改變。
  例如，my_tuple = (1, 2, 3) 創建了一個包含數字 1、2 和 3 的元組。你不能改變元組中的數字，像 my_tuple[0] = 5 這樣的操作會報錯。

• 元組中的可變對象：
  雖然元組本身不可變，但如果元組內包含可變對象，如列表或字典，這些對象的內容是可以改變的。

my_tuple = (1, 2, [3, 4])

# 嘗試改變元組內的列表
my_tuple[2].append(5)
print(my_tuple) #(1, 2, [3, 4, 5])

在這裡，my_tuple[2] 是一個列表 [3, 4]，雖然元組是不可變的，但這個列表是可變的，所以我們可以對列表進行修改，像 append(5) 這樣操作。

哪些可以當作字典的 key？

在 Python 中，字典的 key 必須是不可變（immutable）的物件。這意味著可以作為字典 key 的物件類型包括：

• 字串（string）
• 整數（integer）
• 浮點數（float）
• 元組（tuple），但元組中的元素也必須是不可變的。

現在來看兩個例子：
('tom', [14, 23, 26])
這個元組內包含了一個可變的列表 [14, 23, 26]。由於列表是可變的，這個元組不能作為字典的 key。

['string', (15, 16)]
這是個列表，而列表本身是可變的，所以它不能作為字典的 key。

哪些可以當作字典的 key？

• ('tom', [14, 23, 26])：❌ 不可以，因為包含可變的列表。
• ['string', (15, 16)]：❌ 不可以，因為列表是可變的。
• 如果你要用元組作為字典的 key，該元組內的所有元素都必須是不可變的，例如 ('tom', (14, 23, 26)) 就是合法的字典 key，因為元組內的所有元素都是不可變的。